/**
 * 服务配置和优化工具
 */

// 服务端点配置
export const SERVICE_ENDPOINTS = {
  // AI服务
  AI_SERVICE: import.meta.env.VITE_AI_SERVICE_URL || 'http://localhost:8002',
  
  // 爬虫服务
  CRAWLER_SERVICE: import.meta.env.VITE_CRAWLER_SERVICE_URL || 'http://localhost:8001',
  
  // 认证服务
  AUTH_SERVICE: import.meta.env.VITE_AUTH_SERVICE_URL || 'http://localhost:8003',
  
  // API网关 (未来使用)
  API_GATEWAY: import.meta.env.VITE_API_GATEWAY_URL || 'http://localhost:8000',
} as const;

// 服务健康检查配置
export const HEALTH_CHECK_CONFIG = {
  interval: 30000, // 30秒
  timeout: 5000,   // 5秒超时
  retryCount: 3,
} as const;

// 请求优化配置
export const REQUEST_CONFIG = {
  // 默认超时时间
  defaultTimeout: 10000,
  
  // 不同类型请求的超时配置
  timeouts: {
    ai_generation: 30000,  // AI生成需要更长时间
    file_upload: 60000,    // 文件上传
    data_fetch: 10000,     // 数据获取
    auth: 5000,            // 认证请求
  },
  
  // 重试配置
  retry: {
    maxAttempts: 3,
    backoffMultiplier: 2,
    maxBackoff: 10000,
  },
  
  // 缓存配置
  cache: {
    // 不同数据类型的缓存时间（毫秒）
    ttl: {
      hot_items: 5 * 60 * 1000,      // 热点数据 5分钟
      user_info: 10 * 60 * 1000,     // 用户信息 10分钟
      model_config: 30 * 60 * 1000,  // 模型配置 30分钟
      static_data: 60 * 60 * 1000,   // 静态数据 1小时
    },
    maxSize: 100, // 最大缓存条目数
  },
  
  // 并发控制
  concurrency: {
    maxConcurrent: 6,    // 最大并发请求数
    queueTimeout: 30000, // 队列超时时间
  },
} as const;

// 性能监控配置
export const MONITORING_CONFIG = {
  enabled: import.meta.env.VITE_ENABLE_MONITORING === 'true',
  
  // 慢请求阈值（毫秒）
  slowRequestThreshold: {
    api: 2000,
    ai: 10000,
    file: 5000,
  },
  
  // 采样率 (0-1)
  samplingRate: import.meta.env.DEV ? 1 : 0.1,
  
  // 上报间隔
  reportInterval: 60000, // 1分钟
} as const;

// 服务降级配置
export const FALLBACK_CONFIG = {
  // 启用降级
  enabled: true,
  
  // 降级策略
  strategies: {
    // AI服务降级：使用更快的模型或返回缓存结果
    ai_service: {
      useCache: true,
      fallbackModel: 'gpt-3.5-turbo',
      maxCacheAge: 24 * 60 * 60 * 1000, // 24小时
    },
    
    // 热点数据降级：返回本地缓存
    hot_data: {
      useLocalCache: true,
      staticFallback: true,
    },
  },
} as const;

/**
 * 服务健康检查器
 */
export class ServiceHealthChecker {
  private healthStatus = new Map<string, boolean>();
  private checkIntervals = new Map<string, NodeJS.Timer>();
  
  /**
   * 开始健康检查
   */
  startHealthCheck(serviceName: string, endpoint: string) {
    // 立即执行一次检查
    this.checkHealth(serviceName, endpoint);
    
    // 设置定期检查
    const interval = setInterval(() => {
      this.checkHealth(serviceName, endpoint);
    }, HEALTH_CHECK_CONFIG.interval);
    
    this.checkIntervals.set(serviceName, interval);
  }
  
  /**
   * 停止健康检查
   */
  stopHealthCheck(serviceName: string) {
    const interval = this.checkIntervals.get(serviceName);
    if (interval) {
      clearInterval(interval);
      this.checkIntervals.delete(serviceName);
    }
  }
  
  /**
   * 检查服务健康状态
   */
  private async checkHealth(serviceName: string, endpoint: string) {
    try {
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_CONFIG.timeout);
      
      const response = await fetch(`${endpoint}/health`, {
        signal: controller.signal,
      });
      
      clearTimeout(timeoutId);
      
      const isHealthy = response.ok;
      this.healthStatus.set(serviceName, isHealthy);
      
      if (!isHealthy) {
        console.warn(`Service ${serviceName} is unhealthy: ${response.status}`);
      }
    } catch (error) {
      console.error(`Health check failed for ${serviceName}:`, error);
      this.healthStatus.set(serviceName, false);
    }
  }
  
  /**
   * 获取服务健康状态
   */
  isHealthy(serviceName: string): boolean {
    return this.healthStatus.get(serviceName) ?? false;
  }
  
  /**
   * 获取所有服务状态
   */
  getAllStatus(): Record<string, boolean> {
    const status: Record<string, boolean> = {};
    this.healthStatus.forEach((value, key) => {
      status[key] = value;
    });
    return status;
  }
}

/**
 * 请求优先级队列
 */
export class PriorityQueue<T> {
  private queues: Map<number, T[]> = new Map();
  
  enqueue(item: T, priority: number = 0) {
    if (!this.queues.has(priority)) {
      this.queues.set(priority, []);
    }
    this.queues.get(priority)!.push(item);
  }
  
  dequeue(): T | undefined {
    const priorities = Array.from(this.queues.keys()).sort((a, b) => b - a);
    
    for (const priority of priorities) {
      const queue = this.queues.get(priority);
      if (queue && queue.length > 0) {
        return queue.shift();
      }
    }
    
    return undefined;
  }
  
  get size(): number {
    let total = 0;
    this.queues.forEach(queue => {
      total += queue.length;
    });
    return total;
  }
  
  isEmpty(): boolean {
    return this.size === 0;
  }
}

/**
 * 请求去重工具
 */
export class RequestDeduplicator {
  private pendingRequests = new Map<string, Promise<any>>();
  
  /**
   * 执行请求，相同的请求会被去重
   */
  async execute<T>(
    key: string,
    requestFn: () => Promise<T>
  ): Promise<T> {
    // 检查是否有相同的请求正在进行
    if (this.pendingRequests.has(key)) {
      return this.pendingRequests.get(key);
    }
    
    // 执行请求并缓存 Promise
    const promise = requestFn().finally(() => {
      // 请求完成后清理
      this.pendingRequests.delete(key);
    });
    
    this.pendingRequests.set(key, promise);
    return promise;
  }
  
  /**
   * 清理所有pending请求
   */
  clear() {
    this.pendingRequests.clear();
  }
}

// 导出单例
export const healthChecker = new ServiceHealthChecker();
export const requestDeduplicator = new RequestDeduplicator();

// 启动健康检查
if (typeof window !== 'undefined') {
  // 在浏览器环境中启动健康检查
  healthChecker.startHealthCheck('ai', SERVICE_ENDPOINTS.AI_SERVICE);
  healthChecker.startHealthCheck('crawler', SERVICE_ENDPOINTS.CRAWLER_SERVICE);
  healthChecker.startHealthCheck('auth', SERVICE_ENDPOINTS.AUTH_SERVICE);
}